Updating a transport stack in a content centric network

ABSTRACT

One embodiment provides a transport stack updating system that facilitates updating a component of a transport stack of a computer system. During operation, the system sets, by a component of the transport stack, a state of the component as quiesced in response to receiving a pause message. A component in the quiesced state is precluded from processing an interest or a content object. The system determines whether the pause message triggers a rejection passes an acknowledgment message of the pause message up the transport stack. The acknowledgment message indicates that the pause message has been successfully processed by a respective component of the transport stack.

RELATED APPLICATIONS

The subject matter of this application is related to the subject matterin the following applications:

U.S. patent application Ser. No. 13/847,814 , entitled “ORDERED-ELEMENTNAMING FOR NAME-BASED PACKET FORWARDING,” by inventor Ignacio Solis,filed 20 Mar. 2013 (hereinafter “U.S. patent application Ser.13/847,814”);

U.S. patent application Ser. No. 12/338,175 , entitled “CONTROLLING THESPREAD OF INTERESTS AND CONTENT IN A CONTENT CENTRIC NETWORK,” byinventors Van L. Jacobson and Diana K. Smetters, filed 18 Dec. 2008(hereinafter “U.S. patent application Ser. No. 12/338,175”); and

U.S. patent application Ser. No. 14/595,060 , entitled“AUTO-CONFIGURABLE TRANSPORT STACK,” by inventors Ignacio Solis andGlenn C. Scott, filed 12 Jan. 2015 (hereinafter “U.S. patent applicationSer. No. 14/595,060”);

the disclosures of which are herein incorporated by reference in theirentirety.

BACKGROUND

Field

This disclosure is generally related to a transport framework. Morespecifically, this disclosure is related to a method and system forfacilitating command messages to be communicated in a layer-agnosticmanner between components of the same or different stacks.

Related Art

The proliferation of the Internet and e-commerce continues to create avast amount of digital content. Content centric network (CCN)architectures have been designed to facilitate accessing and processingsuch digital content. A CCN includes entities, or nodes, such as networkclients, forwarders (e.g., routers), and content producers, whichcommunicate with each other by sending “interest” packets for variouscontent items and receiving “content object” packets in return. CCNinterests and content objects are identified by their unique names,which are typically hierarchically structured variable-lengthidentifiers (HSVLI). An HSVLI can include contiguous name componentsordered from a most general level to a most specific level.

A CCN node implements a transport stack, which includes layers ofindependent components that forward messages to one another. A componentin the stack can also be referred to as a module. The stack is assembledand initialized at when a CCN node is initiated. The stack implementsCCN protocols and integrates external services, such as caches,identity, key, and certificate services. The stack also facilitatescontrol messages to coordinate operations. The node uses the stack toforward messages with interests and content objects.

Each component of the stack can process the messages in eitherdirection. This can change the system state of the node or modifymessage contents. Furthermore, the component may queue the messages orgenerate new messages. In addition, the node can modify the transportstack (e.g., can insert a new component or remove an existingcomponent). Such modifications may require coordination among thecomponents. In order to avoid duplicate or interfering operations by thecomponents, configuration, control, and management of the components mayrequire the ability to guarantee a known state for a period of timenecessary to implement and activate new state or change itsconfiguration.

SUMMARY

One embodiment provides a transport stack updating system thatfacilitates updating a component of a transport stack of a computersystem. During operation, the system sets, by a component of thetransport stack, a state of the component as quiesced in response toreceiving a pause message. A component in the quiesced state isprecluded from processing an interest or a content object. The systemdetermines whether the pause message triggers a rejection passes anacknowledgment message of the pause message up the transport stack. Theacknowledgment message indicates that the pause message has beensuccessfully processed by a respective component of the transport stack.

In a variation on this embodiment, the component is a final component ofthe transport stack. The system then generates the acknowledgmentmessage in response to receiving the pause message.

In a variation on this embodiment, the system receives an update messageand, in response, updates the component based on the content of theupdate message.

In a variation on this embodiment, the system sends an update failuremessage up the transport stack in response to determining that the pausemessage triggers a rejection.

In a further variation, reasons for rejection include one or more of: astack component detecting a timeout event, processing a back flow, oridentifying inter-dependent messages.

In a variation on this embodiment, the system sets the state of thecomponent as active in response to receiving a resume message. Acomponent in the active state resumes processing an interest or acontent object.

In a variation on this embodiment, the pause message is an interestmessage. The system then transfers control to an administrator agent forupdating the component.

In a variation on this embodiment, a name for a component of thetransport stack is based on one or more of: a hierarchically structuredvariable length identifier (HSVLI), which comprises contiguous namecomponents ordered from a most general level to a most specific level,wherein the HSVLI is applicable in a portal instance corresponding tothe stack; a flat name that does not indicate any hierarchy; a role ofthe component of the stack; and a unique identifier which is specific tothe component of the stack.

BRIEF DESCRIPTION OF THE FIGURES

FIG. 1A illustrates an exemplary content centric network (CCN) thatfacilitates updating a transport stack based on quiescing, in accordancewith an embodiment of the present invention.

FIG. 1B illustrates an exemplary transport stack of a CCN node, inaccordance with an embodiment of the present invention.

FIG. 2A illustrates an exemplary communication that initiates quiescingof a transport stack, in accordance with an embodiment of the presentinvention.

FIG. 2B illustrates an exemplary communication that updates a transportstack, in accordance with an embodiment of the present invention.

FIG. 2C illustrates an exemplary communication that updates a transportstack based on control sharing, in accordance with an embodiment of thepresent invention.

FIG. 2D illustrates an exemplary communication of an unsuccessfulquiescing of a transport stack, in accordance with an embodiment of thepresent invention.

FIG. 3 presents a flow chart illustrating a method for quiescing andupdating a transport stack, in accordance with an embodiment of thepresent invention.

FIG. 4A presents a flow chart illustrating a method for quiescing andupdating a module of a transport stack, in accordance with an embodimentof the present invention.

FIG. 4B presents a flow chart illustrating a method for quiescing andupdating a final stack component of a transport stack, in accordancewith an embodiment of the present invention.

FIG. 5 illustrates an exemplary apparatus that facilitates updating atransport stack based on quiescing, in accordance with an embodiment ofthe present invention.

FIG. 6 illustrates an exemplary computer system that facilitatesupdating a transport stack based on quiescing, in accordance with anembodiment of the present invention.

In the figures, like reference numerals refer to the same figureelements.

DETAILED DESCRIPTION

The following description is presented to enable any person skilled inthe art to make and use the embodiments, and is provided in the contextof a particular application and its requirements. Various modificationsto the disclosed embodiments will be readily apparent to those skilledin the art, and the general principles defined herein may be applied toother embodiments and applications without departing from the spirit andscope of the present disclosure. Thus, the present invention is notlimited to the embodiments shown, but is to be accorded the widest scopeconsistent with the principles and features disclosed herein.

Overview

Embodiments of the present invention solve the problem of efficientlyupdating a stack module of a CCN node by quiescing the stack componentsduring the updating process. In this way, the operations required forthe update can be executed without interruption before the stack isallowed to continue regular operations. The node provides a set ofnetwork components that can be combined into a transport “stack” thatachieves communication functionality.

Each of the components within a transport stack performs a specificfunction, and some components can implement a functionality that is morespecific or more generic than other versions of the same component. Somecomponents may take parameters at load time that define their behavior,and some components may be configured at runtime based on parametersthat they receive from a local application or from a device over thenetwork. For example, some components may adapt to changing operatingenvironment conditions or network conditions over time. The transportstack provides a way for configuration messages and information to besent between the components, thereby allowing components within thestack to communicate with each other.

In some embodiments, an administrator agent of the CCN node can update acomponent of the stack (e.g., add a new component or update an existingcomponent). To ensure consistency, the agent sends a pause message downthe stack. A component receives the pause message and flushes the localbuffer (e.g., empties the message buffer associated with the component).The component stops further processing of messages (e.g., interests andcontent objects), sets the local state as “quiesced,” and passes thepause message down the stack to the next component.

When the pause message reaches the final component of the stack, whichis typically a forwarder adapter, the final component flushes the localbuffer and sets the local state as quiesced. The final component thengenerates an acknowledgment message and sends the acknowledgment messageup the stack. A respective component passes the acknowledgment messageup the stack. The agent receives the acknowledgment message anddetermines that the stack has been successfully quiesced. The agent thenpasses an update message down the stack and updates the component. Whenthe component is updated, the agent passes a resume message down thestack, thereby instructing a respective component to resume operation.

In some embodiments, a transport stack operates under the CCNarchitecture. In CCN, each piece of content is individually named, andeach piece of data is bound to a unique name that distinguishes the datafrom any other piece of data, such as other versions of the same data ordata from other sources. This unique name allows a network device torequest the data by disseminating a request or an interest thatindicates the unique name, and can obtain the data independently of thedata's storage location, network location, application, and means oftransportation. The following terms are used to describe the CCNarchitecture:

Content Object (or “content object”): A single piece of named data,which is bound to a unique name. Content Objects are “persistent,” whichmeans that a Content Object can move around within a computing device,or across different computing devices, but does not change. If anycomponent of the Content Object changes, the entity that made the changecreates a new Content Object that includes the updated content, andbinds the new Content Object to a new unique name.

Unique Names: A name in a CCN is typically location-independent anduniquely identifies a Content Object. A data-forwarding device can usethe name or name prefix to forward a packet toward a network node thatgenerates or stores the Content Object, regardless of a network addressor physical location for the Content Object. In some embodiments, thename may be a hierarchically structured variable-length identifier(HSVLI). The HSVLI can be divided into several hierarchical components,which can be structured in various ways. For example, the individualname components parc, home, ccn, and test.txt can be structured in aleft-oriented, prefix-major fashion to form the name“/parc/home/ccn/test.txt.” Thus, the name “/parc/home/ccn” can be a“parent” or “prefix” of “/parc/home/ccn/test.txt.” Additional componentscan be used to distinguish among different versions of the content item,such as a collaborative document.

In some embodiments, the name can include an identifier, such as a hashvalue that is derived from the Content Object's data (e.g., a checksumvalue) and/or from elements of the Content Object's name. A descriptionof a hash-based name is described in U.S. patent application Ser. No.13/847,814, which is herein incorporated by reference. A name can alsobe a flat label. Hereinafter, “name” is used to refer to any name for apiece of data in a name-data network, such as a hierarchical name orname prefix, a flat name, a fixed-length name, an arbitrary-length name,or a label (e.g., a Multiprotocol Label Switching (MPLS) label).

Interest (or “interest”): A packet that indicates a request for a pieceof data, and includes a name (or a name prefix) for the piece of data. Adata consumer can disseminate a request or Interest across aninformation-centric network, which CCN/NDN routers can propagate towarda storage device (e.g., a cache server) or a data producer that canprovide the requested data to satisfy the request or Interest.

In addition, “lci” and “ccnx” refer to labeled content information andindicate a Universal Resource Indicator (URI) compliant identifier inwhich name segments carry a label. Network protocols such as CCN can uselabeled content information by applying specific labels to each namesegment of a URI. In a hierarchically structured name, a labeled contentname assigns a semantic type or label to each segment. For example, atype of name segment can include a name segment, which is a generic namesegment that includes arbitrary octets, which allows a CCN to use abinary on-the-wire representation for messages.

The methods disclosed herein are not limited to CCN networks and areapplicable to other architectures as well. A description of a CCNarchitecture is described in U.S. patent application Ser. No.12/338,175, which is herein incorporated by reference.

Exemplary Network and Communication

FIG. 1A illustrates an exemplary content centric network (CCN) thatfacilitates updating a transport stack based on quiescing, in accordancewith an embodiment of the present invention. A network 100, which can bea CCN, can include a client device 116, a content-producing device 118,and a router or other forwarding device at nodes 102, 104, 106, 108,110, 112, and 114. A node can be a computer system, an endpointrepresenting users, and/or a device that can generate an interest ororiginate a content object. Suppose that nodes 102 and 104 havetransport stacks 130 and 170, respectively. In a CCN node, the transportstack is often configured based on instructions from an administratoragent. Transport stacks 130 and 170 are usually modified by explicitadministrative commands at runtime.

To update stack 130, node 102 typically quiesces stack 130 so that theoperations associated with the update can be executed withoutinterruption before stack 130 is allowed to continue regular operations.Similarly, node 104 typically quiesces stack 170 to update stack 170.Node 102 can quiesce the entire stack (e.g., each component of stack130) and all message transmissions, or only specific messages ormessages matching a specific set of rules.

In some embodiments, node 102 passes a pause message down stack 130.This pause message can be an interest for a name that each stackcomponent recognizes and processes. Upon receiving the pause message, arespective component of stack 130 flushes its buffer and pauses itsoperations. When node 102 completes updating one or more components ofstack 130, node 102 sends a resume message via stack 130. This resumemessage can be a content object associated with the name. Upon receivingthe resume message, a respective component of stack 130 resumes itsoperations. In this way, the operations required for updating stack 130can be executed without interruption before stack 130 is allowed tocontinue regular operations.

FIG. 1B illustrates an exemplary transport stack of a CCN node, inaccordance with an embodiment of the present invention. In this example,node 102 can include an administrator agent 152, which communicates withtransport stack 130 via a portal 120. Transport stack 130 can includestack components 134.1-134.n. Node 102 can also include forwarder 140(e.g., a network interface card, or a router in a local area network),which can transfer packets between stack 130 (and individual stackcomponents) and network 100. Similarly, node 104 can includeadministrator agent 154, which communicates with transport stack 170 viaportal 160. Transport stack 170 can include stack components174.1-174.p. Node 104 can also include a forwarder 180, which cantransfer packets between stack 170 (and individual stack components) andnetwork 100. Forwarders 140 and 180 can also facilitate the transfer ofpackets directly between individual stack components 134.1-134.n and174.1-174.p, respectively.

Administrator agent 152 can issue a pause message for stack 130. In someembodiments, the head of stack 130 (e.g., stack component 134.1, whichis typically an application program interface (API) adapter), can alsoissue the pause message. Upon receiving the message, each componentflushes its current buffer, quiesces local operations, and forwards themessage via stack 130. In some embodiments, the final component of stack130, which is stack component 134.n, can send an acknowledgment up stack130. Agent 152 can specify a lifetime (e.g., a timeout period) for thepause message for a respective stack component. If a timer representingthe lifetime expires before receiving the acknowledgment, the stackcomponent detects a timeout event, determines that the pause operationhas failed, and resumes regular operations. Since the acknowledgment isnot passed up stack 130, the timeout event is propagated via stack 130to agent 152, thereby resuming operations of a respective stackcomponent.

On the other hand, if the stack component receives the acknowledgmentwithin the lifetime, the stack component passes the acknowledgment upstack 130. Agent 152 receives the acknowledgment and determines thatstack 130 has been quiesced. Agent 152 then updates one or morecomponents of stack 130. When the update operation is completed, agent152 (or the head of stack 130) sends a resume message down stack 130.Upon receiving the message, a respective component restarts regularoperations. In some embodiments, stack component 134.n can send a pausecontent object associated with the name up stack 130. When a stackcomponent receives the content object, the component resumes its regularoperation and passes the content object up stack 130.

In some embodiments, the pause message is applied only to a specificnamespace. Any interest or content object with a name in that namespaceis flushed at stack 130 and is precluded from being processed at stack130. However, any interest or content object with a name outside of thatnamespace is processed based on regular operations of stack 130. In someembodiments, a stack component can reject the pause message and respondwith a pause failure message with an optional reason for the rejection.Reasons for rejection include, but are not limited to, a stack componentdetecting a timeout event, processing a back flow, or identifyinginter-dependent messages.

Exemplary Quiescing of a Transport Stack

FIG. 2A illustrates an exemplary communication that initiates quiescingof a transport stack, in accordance with an embodiment of the presentinvention. In this example, an administrator agent 210 uses API 212 tocommunicate with a portal 220, which interacts with a transport stack230. In FIG. 2A, transport stack 230 includes stack components 232-238.An API adapter 232 can communicate with one or more transport componentsof transport stack 230. A flow controller 234 can shape and managetraffic, pipeline and transmit interests, and order content objects. Averifier/signer 236 can encode and sign content objects destined for anetwork element, decode and verify content objects destined for anassociated application, encode interests destined for a network element,and decode interests destined for an associated application.

A forwarder adapter 238, which is typically the final component of stack230, can communicate with a forwarder 240. Forwarder 240 can communicatewith other forwarders over a CCN. Other stack components (not shown) caninclude functionality related to security (e.g., encryption, decryption,authentication, data signing, signature verification, trust assessment,and filtering), data-processing (e.g., encoding, decoding,encapsulating, decapsulating, transcoding, compression, extraction, anddecompression), and storage (e.g., data storage, data retrieval fromstorage, deduplication, segmentation, and versioning).

In some embodiments, administrator agent 210 can update a component ofstack 230 (e.g., add a new component or update an existing component).To ensure consistency, agent 210 sends a pause message 252 down stack230. A respective component of stack 230 receives pause message 252 andflushes its local buffer, if any. Some components may just receive andprocess a message (e.g., an interest or a content object), while othercomponents can buffer messages. Suppose that flow controller 234 storesmessages in a buffer 235. Upon receiving pause message 252, flowcontroller 234 flushes buffer 235 (e.g., discards the messages stored inbuffer 235). Upon receiving pause message 252, a respective componentstops further processing of messages, sets the local state as“quiesced,” and passes pause message 252 down stack 230 to the nextcomponent.

When the pause message reaches the final component of stack 230, whichis forwarder adapter 238, forwarder adapter 238 also flushes the localbuffer, if any, and sets the local state as quiesced. Forwarder adapter238 then generates a pause acknowledgment message 254 and sendsacknowledgment message 254 up stack 230. A respective component receivesacknowledgment message 254 without a timer expiring for pause message252, and the component passes acknowledgment message 254 up stack 230.Agent 210 receives acknowledgment message 254 and determines that stack230 has been successfully quiesced.

FIG. 2B illustrates an exemplary communication that updates a transportstack, in accordance with an embodiment of the present invention. Inthis example, upon receiving an acknowledgment message, agent 210determines that stack 230 has been successfully quiesced. Agent 210 thenpasses an update message comprising the updates for a stack component.Suppose that agent 210 is updating the verification protocol ofverifier/signer 236. Agent 210 then generates an update message 262comprising the updated verification protocol and passes update message262 down stack 230. Verifier/signer 236 receives update message 262 fromupper components of stack 230, obtains the updated verification protocolfrom update message 262, and updates verifier/signer 236.

In some embodiments, verifier/signer 236 generates an updateacknowledgment message 264 and sends acknowledgment message 264 up stack230. A respective component passes acknowledgment message 264 up stack230. Agent 210 receives acknowledgment message 264 and determines thatverifier/signer 236 has been successfully updated. Agent 210 thengenerates a resume message 266 and passes resume message 266 down stack230, thereby instructing a respective component to resume operation.Upon receiving resume message 266, a respective component resumesprocessing of messages, sets the local state as “active,” and passesresume message 266 down stack 230 to the next component. When resumemessage 266 reaches forwarder adapter 238, forwarder adapter 238 resumesprocessing of messages and sets the local state as “active.”

FIG. 2C illustrates an exemplary communication that updates a transportstack based on control sharing, in accordance with an embodiment of thepresent invention. In this example, a pause interest message 272 is sentdown transport stack 230 with a pre-agreed-upon name that each componentis capable of recognizing and processing. Agent 210 (or head of stack230, which is API adapter 232) can generate and send pause interestmessage 272. Upon receiving pause interest message 272, a respectivecomponent of stack 230 flushes its current buffer, forwards pauseinterest message 272 via stack 230, quiesces the local component, andwaits for a content object return matching pause interest message 272before processing or forwarding any other messages.

Typically, forwarder adapter 238 is the final component to receive pauseinterest message 272. When pause interest message 272 reaches forwarderadapter 238, forwarder adapter 238 quiesces the local component anddetermines that a respective component between forwarder adapter 238 andAPI adapter 232 has been quiesced. Forwarder adapter 238 then passescontrol to agent 210. In some embodiments, forwarder adapter 238 sends acontrol message 274 (e.g., an inter-process message) to agent 210 viastack 230 to pass the control.

Suppose that agent 210 is updating the verification protocol ofverifier/signer 236. Agent 210 then generates an update message 276comprising the updated verification protocol and passes update message276 down stack 230. Verifier/signer 236 receives update message 276 fromthe upper components of stack 230, obtains the updated verificationprotocol from update message 276, and updates verifier/signer 236.

When the updating process is completed, agent 210 passes the controlback to forwarder adapter 238 (e.g., using a control message, which isnot shown in FIG. 2C). Forwarder adapter 238 constructs a matching pausecontent object 278 and sends pause content object 278 back up transportstack 230. Upon receiving pause content object 278, a respectivecomponent restarts regular operation and sends pause content object 278onward via stack 230. Once pause content object 278 reaches agent 210(or API adapter 232), transport stack 230 resumes its regularoperations.

FIG. 2D illustrates an exemplary communication of an unsuccessfulquiescing of a transport stack, in accordance with an embodiment of thepresent invention. In some embodiments, a stack component can reject apause message and respond with a pause failure message with an optionalreason for the rejection. Reasons for rejection include, but are notlimited to, a stack component detecting a timeout event, processing aback flow, or identifying inter-dependent messages. Suppose that flowcontroller 234 fails to process pause message 252 (e.g., being unable toflush buffer 235 due to inter-dependencies). As a result, flowcontroller 234 rejects pause message 252, generates a pause failuremessage 280 comprising the reason for the rejection, and passes pausefailure message 280 upward via stack 230.

When pause failure message 280 reaches an upstream stack component, suchas API adapter 232, the stack component determines that pause message252 has been rejected, restarts regular operation, and sends pausefailure message 280 onward via stack 230. Upon receiving pause failuremessage 280, agent 210 determines that pause message 252 has beenrejected. Agent 210 can wait for a period of time (e.g., a randomback-off or a pre-determined time) and re-issue pause message 252.

Operations

FIG. 3 presents a flow chart 300 illustrating a method for quiescing andupdating a transport stack, in accordance with an embodiment of thepresent invention. During operation, an administrator agent (or the headof the stack) sends a pause message down the transport stack (operation302) and initiates a timer for a pause acknowledgment message (operation304). The agent checks whether the agent has detected a timeout or apause failure message (operation 306). If the agent detects a timeout ora pause failure message, the agent waits for a period of time (e.g.,based on random back-off or a pre-determined configuration) (operation308) and sends another pause message down the transport stack (operation302). If the agent doesn't detect a timeout or a pause failure message,the agent receives a pause acknowledgment message (operation 310).

The agent then determines that the stack has been quiesced. The agentsends an update message to a respective updating component (i.e., thecomponent that the agent is updating) (operation 312). The updatemessage comprises the update for the updating component. The agent thenchecks whether the update has been successful (operation 314). In someembodiments, the agent determines that the update has been successfulupon receiving an acknowledgment for the update message. If the agentdetermines that the update has not been successful, the agent waits fora period of time (operation 308) and sends another pause message downthe transport stack (operation 302). If the agent determines that theupdate has been successful, the agent sends a resume message down thetransport stack (operation 316).

FIG. 4A presents a flow chart 400 illustrating a method for quiescingand updating a module of a transport stack, in accordance with anembodiment of the present invention. During operation, a stackcomponent, which is not the final component of the stack, receives apause message (operation 402) and checks whether the pause messagetriggers a rejection (operation 404). Reasons for rejection include, butare not limited to, processing a back flow or identifyinginter-dependent messages. If the pause message does not trigger arejection, the component passes the pause message to the next componentdown the transport stack (operation 406) and flushes residual localdata, if any (operation 408).

The component then checks whether the component has received a pauseacknowledgment message (operation 410). If the component has notreceived a pause acknowledgment message, the component checks for atimeout event (operation 412). If the component detects a timeout eventor the pause message triggers a rejection (operation 404), the componentgenerates a pause failure message and passes the pause failure messageto the next component up the transport stack (operation 414). On theother hand, if the component has not received a pause acknowledgmentmessage (operation 410) and doesn't detect a timeout event (operation412), the component continues to flush residual local data, if any(operation 408).

If the component receives a pause acknowledgment message (operation410), the component sets the local state as “quiesced” (operation 416)and passes the pause acknowledgment message to the next component up thetransport stack (operation 418). If the component is the updatingcomponent (denoted with dashed line), the component receives an updatemessage and implements updates to the local component (operation 420).In some embodiments, the component can send an acknowledgment up thestack upon successfully updating the local component. The component thenreceives a resume message (operation 422) and sets the local state as“active” (operation 426).

FIG. 4B presents a flow chart 450 illustrating a method for quiescingand updating a final stack component of a transport stack, in accordancewith an embodiment of the present invention. During operation, thecomponent receives a pause message (operation 452) and checks whetherthe pause message triggers a rejection (operation 454). Reasons forrejection include, but are not limited to, processing a back flow oridentifying inter-dependent messages. If the pause message triggers arejection, the component generates a pause failure message and passesthe pause failure message to the next component up the transport stack(operation 468).

If the pause message does not trigger a rejection, the component flushesresidual local data, if any (operation 456) and sets the local state as“quiesced” (operation 458). The component then passes the pauseacknowledgment message to the next component up the transport stack(operation 460). If the component is the updating component (denotedwith dashed line), the component receives an update message andimplements updates to the local component (operation 462). In someembodiments, the component can send an acknowledgment up the stack uponsuccessfully updating the local component. The component then receives aresume message (operation 464) and sets the local state as “active”(operation 466).

Exemplary Apparatus and Computer System

FIG. 5 illustrates an exemplary apparatus that facilitates updating atransport stack based on quiescing, in accordance with an embodiment ofthe present invention. Apparatus 500 can comprise a plurality ofmodules, which may communicate with one another via a wired or wirelesscommunication channel. Apparatus 500 may be realized using one or moreintegrated circuits, and may include fewer or more modules than thoseshown in FIG. 5. Further, apparatus 500 may be integrated in a computersystem, or realized as a separate device that is capable ofcommunicating with other computer systems and/or devices. Specifically,apparatus 500 can comprise a communication module 502, a quiescingmodule 504, an updating module 506, and a message delivering module 508.

In some embodiments, communication module 502 can send and/or receivedata packets to/from other network nodes across a computer network, suchas a content centric network. Quiescing module 504 can set a state of astack component as “quiesced” or “active” based on a pause message and aresume message, respectively. Quiescing module 504 can also generate anacknowledgment for the pause message. In some embodiments, quiescingmodule 504 can flush a local buffer of the component. Updating module506 can update a component based on an update message. Messagedelivering module 508 can deliver a message to a component via atransport stack (e.g., can send a message up or down the stack).

FIG. 6 illustrates an exemplary computer system 602 that facilitatescommand messages to be communicated in a layer-agnostic manner, inaccordance with an embodiment of the present invention. Computer system602 includes a processor 604, a memory 606, and a storage device 608.Memory 606 can include a volatile memory (e.g., RAM) that serves as amanaged memory, and can be used to store one or more memory pools.Furthermore, computer system 602 can be coupled to a display device 610,a keyboard 612, and a pointing device 614. Storage device 608 can storean operating system 616, a stack updating system 618, and data 632.

Stack updating system 618 can include instructions, which when executedby computer system 602 or processor 604, can cause computer system 602or processor 604 to perform methods and/or processes described in thisdisclosure. Specifically, stack updating system 618 may includeinstructions for sending and/or receiving data packets to/from othernetwork nodes across a computer network, such as a content centricnetwork (communication module 620). Stack updating system 618 can alsoinclude instructions for setting a state of a stack component as“quiesced” or “active” based on a pause message and a resume message,respectively (quiescing module 622). Stack updating system 618 can alsoinclude instructions for generating an acknowledgment for the pausemessage and flushing a local buffer of the component (quiescing module622).

Furthermore, stack updating system 618 can include instructions forupdating a component based on an update message (updating module 624).Stack updating system 618 can include instructions for delivering amessage to a component via a transport stack (e.g., can send a messageup or down the stack) (message delivering module 626). Storage device608 can store an administrator agent 630, which can generate and send apause message, a resume message, and an update message for a transportstack.

Data 632 can include any data that is required as input or that isgenerated as output by the methods and/or processes described in thisdisclosure. Specifically, data 632 can include buffered messages by arespective component. Data 632 can also include a forwarding table ofcomputer system 602.

The data structures and code described in this detailed description aretypically stored on a computer-readable storage medium, which may be anydevice or medium that can store code and/or data for use by a computersystem. The computer-readable storage medium includes, but is notlimited to, volatile memory, non-volatile memory, magnetic and opticalstorage devices such as disk drives, magnetic tape, CDs (compact discs),DVDs (digital versatile discs or digital video discs), or other mediacapable of storing computer-readable media now known or later developed.

The methods and processes described in the detailed description sectioncan be embodied as code and/or data, which can be stored in acomputer-readable storage medium as described above. When a computersystem reads and executes the code and/or data stored on thecomputer-readable storage medium, the computer system performs themethods and processes embodied as data structures and code and storedwithin the computer-readable storage medium.

Furthermore, the methods and processes described above can be includedin hardware modules. For example, the hardware modules can include, butare not limited to, application-specific integrated circuit (ASIC)chips, field-programmable gate arrays (FPGAs), and otherprogrammable-logic devices now known or later developed. When thehardware modules are activated, the hardware modules perform the methodsand processes included within the hardware modules.

The foregoing descriptions of embodiments of the present invention havebeen presented for purposes of illustration and description only. Theyare not intended to be exhaustive or to limit the present invention tothe forms disclosed. Accordingly, many modifications and variations willbe apparent to practitioners skilled in the art. Additionally, the abovedisclosure is not intended to limit the present invention. The scope ofthe present invention is defined by the appended claims.

What is claimed is:
 1. A method, comprising: at a particular componentof a plurality of components of a transport stack of a content centricnetwork node: receiving a pause message while the particular componentis processing interests and/or content objects; determining whether thepause message triggers a rejection; and if it is determined that thepause message does not trigger a rejection: setting a state of theparticular component as quiesced such that the particular component isprecluded from processing the interests and/or the content objects;receiving an update message configured to provide an update for theparticular component; updating the particular component based on theupdate message while the state of the particular component is quiesced;and setting the state of the particular component as active such thatthe particular component resumes processing the interests and/or thecontent objects in accordance with the update.
 2. The method of claim 1,wherein the particular component is a final component of the transportstack, the method further comprising: if it is determined that the pausemessage does not trigger the rejection: generating an acknowledgmentmessage in response to receiving the pause message, wherein theacknowledgment message indicates that the pause message has beensuccessfully processed by the plurality of components; and sending theacknowledgement message up the transport stack.
 3. The method of claim1, further comprising: if it is determined that the pause messagetriggers the rejection: sending a pause failure message up the transportstack, wherein the pause failure message indicates that the pausemessage has not been successfully processed by the plurality ofcomponents.
 4. The method of claim 3, wherein determining that the pausemessage triggers the rejection includes one or more of: detecting atimeout event, processing a back flow, and identifying inter-dependentmessages.
 5. The method of claim 1, wherein the pause message is aninterest message, the method further comprising: if it is determinedthat the pause message does not trigger the rejection: sending a controlmessage to an administrator agent, wherein the control message transferscontrol to the administrator agent for updating the particularcomponent.
 6. The method of claim 1, wherein a name for the particularcomponent of the transport stack is based on one or more of: ahierarchically structured variable length identifier (HSVLI), whichcomprises contiguous name components ordered from a most general levelto a most specific level, wherein the HSVLI is applicable in a portalinstance corresponding to the transport stack; a flat name that does notindicate any hierarchy; a role of the particular component of thetransport stack; and a unique identifier which is specific to theparticular component of the transport stack.
 7. The method of claim 1,further comprising: if it is determined that the pause message does nottrigger the rejection: flushing a local buffer of the particularcomponent.
 8. The method of claim 1, further comprising: if it isdetermined that the pause message does not trigger the rejection:receiving a resume message configured to instruct the particularcomponent to set the state of the particular component as active.
 9. Acomputer system for updating a transport stack, the system comprising: aprocessor; and a storage device storing instructions that when executedby the processor cause the processor to perform a method at a particularcomponent of a plurality of components of the transport stack of acontent centric network node, the method comprising: receiving a pausemessage while the particular component is processing interests and/orcontent objects; determining whether the pause message triggers arejection; and if it is determined that the pause message does nottrigger a rejection: setting a state of the particular component asquiesced such that the particular component is precluded from processingthe interests and/or the content objects; receiving an update messageconfigured to provide an update for the particular component; updatingthe particular component based on the update message while the state ofthe particular component is quiesced; and setting the state of theparticular component as active such that the particular componentresumes processing the interests and/or the content objects inaccordance with the update.
 10. The computer system of claim 9, whereinthe particular component is a final component of the transport stack,the method further comprising: if it is determined that the pausemessage does not trigger the rejection: generating an acknowledgmentmessage in response to receiving the pause message, wherein theacknowledgment message indicates that the pause message has beensuccessfully processed by the plurality of components; and sending theacknowledgement message up the transport stack.
 11. The computer systemof claim 9, wherein the method further comprises: if it is determinedthat the pause message triggers the rejection: sending a pause failuremessage up the transport stack, wherein the pause failure messageindicates that the pause message has not been successfully processed bythe plurality of components.
 12. The computer system of claim 11,wherein determining that the pause message triggers the rejectionincludes one or more of: detecting a timeout event, processing a backflow, and identifying inter-dependent messages.
 13. The computer systemof claim 9, wherein the pause message is an interest message, the methodfurther comprising: if it is determined that the pause message does nottrigger the rejection: sending a control message to an administratoragent, wherein the control message transfers control to theadministrator agent for updating the particular component.
 14. Thecomputer system of claim 9, wherein a name for the particular componentof the transport stack is based on one or more of: a hierarchicallystructured variable length identifier (HSVLI), which comprisescontiguous name components ordered from a most general level to a mostspecific level, wherein the HSVLI is applicable in a portal instancecorresponding to the transport stack; a flat name that does not indicateany hierarchy; a role of the particular component of the transportstack; and a unique identifier which is specific to the particularcomponent of the transport stack.
 15. A non-transitory computer-readablestorage medium storing instructions that when executed by a processorcause the processor to perform a method at a particular component of aplurality of components of a transport stack of a content centricnetwork node, the method comprising: receiving a pause message while theparticular component is processing interests and/or content objects;determining whether the pause message triggers a rejection; and if it isdetermined that the pause message does not trigger a rejection: settinga state of the particular component as quiesced such that the particularcomponent is precluded from processing the interests and/or the contentobjects; receiving an update message configured to provide an update forthe particular component; updating the particular component based on theupdate message while the state of the particular component is quiesced;and setting the state of the particular component as active such thatthe particular component resumes processing the interests and/or thecontent objects in accordance with the update.
 16. The storage medium ofclaim 15, wherein the particular component is a final component of thetransport stack, the method further comprising: generating anacknowledgment message in response to receiving the pause message,wherein the acknowledgment message indicates that the pause message hasbeen successfully processed by the plurality of components; and sendingthe acknowledgement message up the transport stack.
 17. The storagemedium of claim 15, the method further comprising: if it is determinedthat the pause message triggers the rejection: sending a pause failuremessage up the transport stack, wherein the pause failure messageindicates that the pause message has not been successfully processed bythe plurality of components.
 18. The storage medium of claim 17, whereindetermining that the pause message triggers the rejection includes oneor more of: detecting a timeout event, processing a back flow, andidentifying inter-dependent messages.
 19. The storage medium of claim15, wherein the pause message is an interest message, the method furthercomprising: if it is determined that the pause message does not triggerthe rejection: sending a control message to an administrator agent,wherein the control message transfers control to the administrator agentfor updating the particular component.
 20. The storage medium of claim15, wherein a name for the particular component of the transport stackis based on one or more of: a hierarchically structured variable lengthidentifier (HSVLI), which comprises contiguous name components orderedfrom a most general level to a most specific level, wherein the HSVLI isapplicable in a portal instance corresponding to the transport stack; aflat name that does not indicate any hierarchy; a role of the particularcomponent of the transport stack; and a unique identifier which isspecific to the particular component of the transport stack.